home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / tex29 / sttexsrc.zoo / src / texext.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-03-13  |  7.2 KB  |  352 lines
  1.  
  2. /*
  3.  * @(#)texext.c 2.5 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "token.h"
  15. #include "box.h"
  16. #include "scan.h"
  17. #include "def.h"
  18. #include "tokenstack.h"
  19. #include "tokenlists.h"
  20. #include "evalstack.h"
  21. #include "file.h"
  22. #include "dvi.h"
  23. #include "texext.h"
  24.  
  25. alpha_file  write_file[16];
  26.  
  27. bool    write_open[18];
  28. ptr     write_loc;
  29.  
  30. do_extension ()
  31. {
  32.     int     i;
  33.     int     j;
  34.     int     k;
  35.     ptr     p;
  36.     ptr     q;
  37.     ptr     r;
  38.  
  39.     switch (cur_chr)
  40.     {
  41.     case OPEN_NODE:
  42.         new_write(OPEN_NODE_SIZE);
  43.         scan_optional_equals();
  44.         scan_file_name();
  45.         open_name(tail) = cur_name;
  46.         open_area(tail) = cur_area;
  47.         open_ext(tail) = cur_ext;
  48.         break;
  49.     
  50.     case WRITE_NODE:
  51.         k = cur_cs;
  52.         new_write(WRITE_NODE_SIZE);
  53.         cur_cs = k;
  54.         scan_toks(FALSE, FALSE);
  55.         write_tokens(tail) = def_ref;
  56.         break;
  57.     
  58.     case CLOSE_NODE:
  59.         new_write(WRITE_NODE_SIZE);
  60.         write_tokens(tail) = NULL;
  61.         break;
  62.     
  63.     case SPECIAL_NODE:
  64.         new_whatsit(SPECIAL_NODE, WRITE_NODE_SIZE);
  65.         cur_cs = k;
  66.         scan_toks(FALSE, TRUE);
  67.         write_tokens(tail) = def_ref;
  68.         break;
  69.  
  70.     case IMMEDIATE_CODE:
  71.         get_x_token();
  72.         if (cur_cmd == EXTENSION && cur_chr <= CLOSE_NODE) {
  73.             p = tail;
  74.             do_extension();
  75.             out_whatsit(tail);
  76.             flush_node_list(tail);
  77.             tail = p;
  78.             link(p) = NULL;
  79.         } else back_input();
  80.         break;
  81.  
  82.     default:
  83.         confusion("ext1");
  84.         break;
  85.     }
  86. }
  87.  
  88. new_whatsit (s, w)
  89.     int     s;
  90.     int     w;
  91. {
  92.     ptr     p;
  93.  
  94.     p = get_node(w);
  95.     type(p) = WHATSIT_NODE;
  96.     subtype(p) = s;
  97.     link(tail) = p;
  98.     tail = p;
  99. }
  100.  
  101. show_whatsit (p)
  102.     ptr     p;
  103. { 
  104.     switch (subtype(p)) 
  105.     { 
  106.     case OPEN_NODE: 
  107.         print_write("openout", p);
  108.         print_char('='); 
  109.         print_file_name(open_name(p), open_area(p), open_ext(p)); 
  110.         break; 
  111.      
  112.     case WRITE_NODE: 
  113.         print_write("write", p); 
  114.         print_mark(write_tokens(p)); 
  115.         break; 
  116.      
  117.     case CLOSE_NODE: 
  118.         print_write("closeout", p); 
  119.         break; 
  120.     
  121.     case SPECIAL_NODE: 
  122.         print_esc("special"); 
  123.         print_mark(write_tokens(p)); 
  124.         break; 
  125.      
  126.     default: 
  127.         print("whatsit?"); 
  128.         break;
  129.     } 
  130. } 
  131.  
  132. ptr
  133. copy_whatsit (p)
  134.     ptr     p;
  135. { 
  136.     ptr     q;
  137.  
  138.     switch (subtype(p)) 
  139.     { 
  140.     case OPEN_NODE: 
  141.         q = get_node(OPEN_NODE_SIZE); 
  142.         mem[q + 2] = mem[p + 2];
  143.         mem[q + 1] = mem[p + 1];
  144.         break; 
  145.      
  146.     case WRITE_NODE: 
  147.     case SPECIAL_NODE:
  148.         q = get_node(WRITE_NODE_SIZE); 
  149.         add_token_ref(write_tokens(p)); 
  150.         mem[q + 1] = mem[p + 1];
  151.         break; 
  152.      
  153.     case CLOSE_NODE: 
  154.         q = get_node(WRITE_NODE_SIZE); 
  155.         mem[q + 1] = mem[p + 1];
  156.         break; 
  157.  
  158.     default:
  159.         confusion("ext2");
  160.         break;
  161.     }
  162.     return q;
  163. }
  164.             
  165. free_whatsit (p)
  166.     ptr     p;
  167. { 
  168.     switch (subtype(p)) 
  169.     { 
  170.     case OPEN_NODE: 
  171.         free_node(p, OPEN_NODE_SIZE); 
  172.         break; 
  173.      
  174.     case WRITE_NODE: 
  175.     case SPECIAL_NODE:
  176.         delete_token_ref(write_tokens(p)); 
  177.         free_node(p, WRITE_NODE_SIZE); 
  178.         break; 
  179.      
  180.     case CLOSE_NODE: 
  181.         free_node(p, WRITE_NODE_SIZE); 
  182.         break; 
  183.     
  184.     default:
  185.         confusion("ext3");
  186.         break;
  187.     } 
  188. }
  189.  
  190. out_whatsit (p)
  191.     ptr     p;
  192. {
  193.     short   j;
  194.  
  195.     switch (subtype(p))
  196.     {
  197.     case OPEN_NODE:
  198.     case WRITE_NODE:
  199.     case CLOSE_NODE:
  200.         if (!doing_leaders) {
  201.             j = write_stream(p);
  202.             if (subtype(p) == WRITE_NODE)
  203.                 out_write(p);
  204.             else {
  205.                 if (write_open[j])
  206.                     a_close(write_file[j]);
  207.                 if (subtype(p) == CLOSE_NODE)
  208.                     write_open[j] = FALSE;
  209.                 else {
  210.                     cur_name = open_name(p);
  211.                     cur_area = open_area(p);
  212.                     cur_ext = open_ext(p);
  213.                     if (cur_ext == null_str)
  214.                         cur_ext = str_tex;
  215.                     if (cur_area == null_str)
  216.                         cur_area = job_area;
  217.                     pack_cur_name();
  218.                     if ((write_file[j] = a_open_out()) == NULL) {
  219.                         cur_area = null_str;
  220.                         pack_cur_name();
  221.                         while ((write_file[j] = a_open_out()) == NULL)
  222.                             prompt_file_name("output file name", str_tex);
  223.                     }
  224.                     write_open[j] = TRUE;
  225.                 }
  226.             }
  227.         }
  228.         break;
  229.  
  230.     case SPECIAL_NODE:
  231.         out_special(p);
  232.         break;
  233.     
  234.     default:
  235.         confusion("ext4");
  236.         break;
  237.     }
  238. }
  239.  
  240. new_write (w)
  241.     int     w;
  242. {
  243.     ptr     p;
  244.  
  245.     new_whatsit(cur_chr, w);
  246.     if (w != WRITE_NODE_SIZE)
  247.         scan_four_bit_int();
  248.     else {
  249.         scan_int(); 
  250.         if (cur_val < 0)
  251.             cur_val = 17;
  252.         else if (cur_val > 15)
  253.             cur_val = 16;
  254.     }
  255.     write_stream(tail) = cur_val;
  256. }
  257.  
  258. print_write (s, p)
  259.     chrs    s;
  260.     ptr     p;
  261. {
  262.     print_esc(s);
  263.     if (write_stream(p) < 16)
  264.         print_int(write_stream(p));
  265.     else if (write_stream(p) == 16)
  266.         print_char('*');
  267.     else print_char('-');
  268. }
  269.  
  270. out_write (p)
  271.     ptr     p;
  272. {
  273.     int     j;
  274.     ptr     q;
  275.     ptr     r;
  276.     int     old_mode;
  277.     int     old_setting;
  278.  
  279.     q = new_token();
  280.     token(q) = RIGHT_BRACE_TOKEN + '}';
  281.     r = new_token();
  282.     token_link(q) = r;
  283.     token(r) = END_WRITE_TOKEN;
  284.     ins_list(q);
  285.     begin_token_list(write_tokens(p), WRITE_TEXT);
  286.     q = new_token();
  287.     token(q) = LEFT_BRACE_TOKEN + '{';
  288.     ins_list(q);
  289.     old_mode = mode;
  290.     mode = 0;
  291.     cur_cs = write_loc;
  292.     scan_toks(FALSE, TRUE);
  293.     get_token();
  294.     if (cur_tok != END_WRITE_TOKEN) {
  295.         print_err("Unbalanced write command");
  296.         help_unbal_write();
  297.         error();
  298.         do get_token();
  299.         while (cur_tok != END_WRITE_TOKEN);
  300.     }
  301.     mode = old_mode;
  302.     end_token_list();
  303.     old_setting = selector;
  304.     j = write_stream(p);
  305.     if (write_open[j])
  306.         selector = j;
  307.     else {
  308.         if (j == 17 && selector == TERM_AND_LOG)
  309.             selector = LOG_ONLY;
  310.         print_nl("");
  311.     }
  312.     show_token_list(token_link(def_ref), NULL, 10000000);
  313.     print_ln();
  314.     flush_list(def_ref);
  315.     selector = old_setting;
  316. }
  317.  
  318. out_special (p)
  319.     ptr     p;
  320. {
  321.     int     old_setting;
  322.     int     k;
  323.  
  324.     synch_h();
  325.     synch_v();
  326.     old_setting = selector;
  327.     selector = NEW_STRING;
  328.     show_token_list(token_link(write_tokens(p)),NULL,(val)POOL_SIZE-pool_ptr);
  329.     selector = old_setting;
  330.     str_room(1);
  331.     if (cur_length() < 256) {
  332.         dvi_out(XXX1);
  333.         dvi_out(cur_length());
  334.     } else {
  335.         dvi_out(XXX4);
  336.         dvi_four(cur_length());
  337.     }
  338.     for (k = str_start[str_ptr]; k < pool_ptr; incr(k))
  339.         dvi_out(str_pool[k]);
  340.     pool_ptr = str_start[str_ptr];
  341. }
  342.  
  343. /*
  344.  *  Help text
  345.  */
  346.  
  347. help_unbal_write ()
  348. {
  349.     help2("On this page there's a \\write with fewer real {'s than }'s.",
  350.     "I can't handle that very well; good luck.");
  351. }
  352.